# Imports
import pygame
import random
import serial
import sys

eps = 0.5 # filter time constant
filter1 = 0.0 # filtered value
filter2 = 0.0 # filtered value
filter3 = 0.0 # filtered value
filter1a = 0.0 # filtered value
filter2a = 0.0 # filtered value
filter3a = 0.0 # filtered value
filter4 = 0.0 # filtered value
filter5 = 0.0 # filtered value

# Initialize the game engine
pygame.init()

black = [ 0, 0, 0]
gray25 = [90,90,90]
gray50 = [127,127,127]
gray75 = [191,191,191]
white = [255,255,255]

delta = [2,2]

day_night = "night"
num_drops = 100
screen_size = 800
dir_band = .04
speed_band = .05
step_ave = 0.0
step_ave0 = 1.0

def get_sensors():
   global filter1, filter2, filter3, filter1a, filter2a, filter3a,filter4, filter5, eps, delta, day_night, step_ave, step_ave0
   #
   # idle routine
   #
   byte2 = 0
   byte3 = 0
   byte4 = 0
   ser.flush()
   #
   # find framing 
   #
   while 1:
      byte1 = byte2
      byte2 = byte3
      byte3 = byte4
      byte4 = ord(ser.read())
      if ((byte1 == 1) & (byte2 == 2) & (byte3 == 3) & (byte4 == 4)):
         break
   #
   # read and plot
   #
   up_low1 = ord(ser.read())
   up_high1 = ord(ser.read())
   down_low1 = ord(ser.read())
   down_high1 = ord(ser.read())
   up_low2 = ord(ser.read())
   up_high2 = ord(ser.read())
   down_low2 = ord(ser.read())
   down_high2 = ord(ser.read())
   up_low3 = ord(ser.read())
   up_high3 = ord(ser.read())
   down_low3 = ord(ser.read())
   down_high3 = ord(ser.read())
   up_value1 = 256*up_high1 + up_low1
   down_value1 = 256*down_high1 + down_low1
   up_value2 = 256*up_high2 + up_low2
   down_value2 = 256*down_high2 + down_low2
   up_value3 = 256*up_high3 + up_low3
   down_value3 = 256*down_high3 + down_low3
   value1 = (up_value1 + (1023 - down_value1))/2.0
   value2 = (up_value2 + (1023 - down_value2))/2.0
   value3 = (up_value3 + (1023 - down_value3))/2.0
   filter1 = (1-eps)*filter1 + eps*value1
   filter2 = (1-eps)*filter2 + eps*value2
   filter3 = (1-eps)*filter3 + eps*value3

   up_low1a = ord(ser.read())
   up_high1a = ord(ser.read())
   down_low1a = ord(ser.read())
   down_high1a = ord(ser.read())
   up_low2a = ord(ser.read())
   up_high2a = ord(ser.read())
   down_low2a = ord(ser.read())
   down_high2a = ord(ser.read())
   up_low3a = ord(ser.read())
   up_high3a = ord(ser.read())
   down_low3a = ord(ser.read())
   down_high3a = ord(ser.read())
   up_value1a = 256*up_high1a + up_low1a
   down_value1a = 256*down_high1a + down_low1a
   up_value2a = 256*up_high2a + up_low2a
   down_value2a = 256*down_high2a + down_low2a
   up_value3a = 256*up_high3a + up_low3a
   down_value3a = 256*down_high3a + down_low3a
   value1a = (up_value1a + (1023 - down_value1a))/2.0
   value2a = (up_value2a + (1023 - down_value2a))/2.0
   value3a = (up_value3a + (1023 - down_value3a))/2.0
   filter1a = (1-eps)*filter1a + eps*value1a
   filter2a = (1-eps)*filter2a + eps*value2a
   filter3a = (1-eps)*filter3a + eps*value3a

   photo_low = ord(ser.read())
   photo_high = ord(ser.read())
   photo_value = 256*photo_high + photo_low
   filter4 = (1-eps)*filter4 + eps*photo_value

   led_low = ord(ser.read())
   led_high = ord(ser.read())
   led_value = 256*led_high + led_low
   filter5 = (1-eps)*filter5 + eps*led_value


   step_ave = (filter2+filter2a)/2

   if step_ave/step_ave0 >= 1-speed_band: step = 1
   elif step_ave/step_ave0 >= 1-4*speed_band: step = 2
   else: step = 4

   if  (filter2-filter2a)/step_ave <= -1*dir_band: delta = [-1,step]
   elif (filter2-filter2a)/step_ave <= dir_band: delta = [0,step]
   else: delta = [1,step]

   if  filter4 <= 100: day_night = "day"
   else: day_night = "night"


# Set the height and width of the screen
size=[screen_size,screen_size]
screen=pygame.display.set_mode(size)
pygame.display.set_caption("Digital Rain")

droplets=[]
bkg_colors=[]

#
#  check command line arguments
#
if (len(sys.argv) != 2):
   print "command line: rain.py serial_port"
   sys.exit()
port = sys.argv[1]
#
# open serial port
#
ser = serial.Serial(port,57600)
ser.setDTR()

# Loop num_drops times and add a star in a random x,y position
for i in range(num_drops):
    x=random.randrange(0,screen_size)
    y=random.randrange(0,screen_size)
    droplets.append([x,y])

for i in range(30): get_sensors()
step_ave0=step_ave

#Loop until the user clicks the close button.
done=False
while done==False:

    for event in pygame.event.get(): # User did something
        if event.type == pygame.QUIT: # If user clicked close
            done=True # Flag that we are done so we exit this loop

    get_sensors()

    # Set the screen background
    if day_night == "day":
       screen.fill(white)
       bkg_colors = [black, gray25, gray50,gray75,white]
    else:
       screen.fill(black)
       bkg_colors = [white, gray75, gray50,gray25,black]

    # Display each drop
    for i in range(len(droplets)):
        # Draw the droplets
        pygame.draw.circle(screen,bkg_colors[0],[int(droplets[i][0]),int(droplets[i][1])],2)
        pygame.draw.circle(screen,bkg_colors[1],[int(droplets[i][0]-2*delta[0]),int(droplets[i][1]-2*delta[1])],2)
        pygame.draw.circle(screen,bkg_colors[2],[int(droplets[i][0]-4*delta[0]),int(droplets[i][1]-4*delta[1])],2)
        pygame.draw.circle(screen,bkg_colors[3],[int(droplets[i][0]-6*delta[0]),int(droplets[i][1]-6*delta[1])],2)
        
        # Falling movement of droplets
        droplets[i][0]+=delta[0]
        droplets[i][1]+=delta[1]
        
        # If the drop has moved off the bottom of the screen
        if droplets[i][1] > screen_size:
            # Reset it just above the top
            y=random.randrange(-50,-10)
            droplets[i][1]=y
            # Give it a new x position
            x=random.randrange(0,screen_size)
            droplets[i][0]=x
            
    # Update the screen.
    pygame.display.flip()
            
pygame.quit ()